// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129
const db=uniCloud.databaseForJQL()
const dbb=uniCloud.database()

module.exports = {
	_before: function () { // 通用预处理器

	},
	/**
	 * method1方法描述
	 * @param {string} param1 参数1描述
	 * @returns {object} 返回值描述
	 */
      /**
       * 获取审核人列表
       * @param {string} id - 服务商主体编号
       * @return {Array} data -员工列表
       */
      async getApproverList(mainBody) {
      	const DbnameMap={wms:'warehouse',ums:"supplier"}
      	let Dbname=DbnameMap[mainBody.type]
      	
      	try {
      		const r = await db.collection(Dbname).where({
      			id: mainBody.id,
      			
      		}).field({
      			user:true
      		}).get();
      
      		if (r.data && r.data.length > 0) {
      			return {
      				code: true,
      				data: r.data[0]
      			};
      		} else {
      			return {
      				code: false,
      				errMsg: "未找到匹配数据"
      			};
      		}
      	} catch (e) {
      		console.error("获取审批人列表失败:", e);
      		return {
      			code: false,
      			errMsg: e.message || "数据库操作失败"
      		};
      	}
      },
	  /**
	   * 从流程的nodes数组中删除特定节点ID
	   * @param {string} flowId - 流程ID
	   * @param {string} nodeId - 要删除的节点ID
	   */
	  async removeNodeFromFlow(flowId, nodeId) {
	  	try {
	  		// 1. 验证流程是否存在
	  		const flow = await dbb.collection('flow').where({
	  			id: flowId
	  		}).get();
	  		if (flow.data.length === 0) {
	  			return {
	  				code: false,
	  				errMsg: `流程ID ${flowId} 不存在`
	  			};
	  		}
	  
	  		// 2. 使用pull操作符删除数组中的nodeId
	  		const res = await dbb.collection('flow').where({
	  			id: flowId
	  		}).update({
	  			nodes: dbb.command.pull(nodeId)
	  		});
	  		console.log("删除节点打印" + JSON.stringify(res));
	  		// 3. 检查操作结果
	  		if (res.updated > 0) {
	  			// 可选：同步删除node节点数据
	  			await dbb.collection('flowNode').where({
	  				id: nodeId
	  			}).remove();
	  			return {
	  				code: true,
	  				errMsg: `已从流程中移除节点 ${nodeId}`
	  			};
	  		} else {
	  			return {
	  				code: false,
	  				errMsg: `节点ID ${nodeId} 不在流程的nodes数组中`
	  			};
	  		}
	  	} catch (e) {
	  		return {
	  			code: false,
	  			errMsg: `删除失败：${e.message}`
	  		};
	  	}
	  },
	  async removeFlow(flowId) {
	  	try {
	  		const r = await db.collection('flow').where({
	  			id: flowId
	  		}).remove();
	  
	  		// 检查实际删除的记录数
	  		if (r.deleted > 0) {
	  			return {
	  				code: true,
	  				errMsg: "删除成功"
	  			};
	  		} else {
	  			return {
	  				code: false,
	  				errMsg: "未找到匹配的记录，删除失败"
	  			};
	  		}
	  	} catch (e) {
	  		return {
	  			code: false,
	  			errMsg: e.message || "数据库操作失败"
	  		};
	  	}
	  },
	  async flowUpdate( data) {
	  	try {
	  		const r = await dbb.collection('flow').where({
	  			id: data.id
	  		}).update(data);
	  
	  		if (r.updated > 0) {
	  			return {
	  				code: true,
	  				errMsg: '更新成功'
	  			};
	  		} else {
	  			return {
	  				code: false,
	  				errMsg: '未找到匹配数据，更新失败'
	  			};
	  		}
	  	} catch (e) {
	  		return {
	  			code: false,
	  			errMsg: e.message || '数据库操作失败'
	  		};
	  	}
	  },
	  
	  /**
	   * 从流程的nodes数组中删除特定节点ID
	   * @param {string} flowId - 流程ID
	   * @param {object} param - 节点对象
	   */
	  async flowNodeAdd(flowId, param) {
	  	try {
	  		// 1. 枚举值验证（根据flowNode集合的实际枚举定义调整）
	  		const enumValidations = [{
	  				field: 'type',
	  				values: ['serial', 'parallel'],
	  				message: '节点类型必须为"serial"或"parallel"'
	  			},
	  			{
	  				field: 'status',
	  				values: ['active', 'inactive'],
	  				message: '节点状态必须为"active"或"inactive"'
	  			},
	  			{
	  				field: 'passCondition',
	  				values: ['all', 'majority', 'any'],
	  				message: '通过条件必须为"all"、"majority"或"any"'
	  			}
	  		];
	  
	  		// 执行验证
	  		for (const validation of enumValidations) {
	  			const {
	  				field,
	  				values,
	  				message
	  			} = validation;
	  			if (param.hasOwnProperty(field) && !values.includes(param[field])) {
	  				return {
	  					code: false,
	  					errMsg: `${message}，当前值：${param[field]}`
	  				};
	  			}
	  		}
	  
	  		// 2. 验证流程是否存在
	  		const flowExist = await dbb.collection('flow').where({
	  			id: flowId
	  		}).count();
	  		if (flowExist.total === 0) {
	  			return {
	  				code: false,
	  				errMsg: `流程ID ${flowId} 不存在`
	  			};
	  		}
	  
	  		// 3. 生成节点ID（若param中没有id）
	  		if (!param.id) {
	  			param.id = dbb.database().generateId(); // 使用数据库生成唯一ID
	  		}
	  
	  		// 4. 使用事务确保操作原子性
	  		const transaction = await dbb.startTransaction();
	  		try {
	  			// 4.1 添加节点
	  			const nodeResult = await transaction.collection('flowNode').add(param);
	  			if (!nodeResult.id) {
	  				throw new Error('节点添加失败');
	  			}
	  
	  			// 4.2 关联流程
	  			const flowResult = await transaction.collection('flow').where({
	  				id: flowId
	  			}).update({
	  				nodes: dbb.command.push(param.id)
	  			});
	  			if (flowResult.modifiedCount === 0) {
	  				throw new Error('流程节点关联失败');
	  			}
	  
	  			// 提交事务
	  			await transaction.commit();
	  			return {
	  				code: true,
	  				errMsg: "节点增加成功",
	  				data: {
	  					nodeId: param.id
	  				}
	  			};
	  		} catch (e) {
	  			// 回滚事务
	  			await transaction.rollback();
	  			throw e;
	  		}
	  
	  	} catch (e) {
	  		return {
	  			code: false,
	  			errMsg: `操作失败：${e.message || e}`
	  		};
	  	}
	  },
    async getFlow(mainBody) {
    	try {
    		const r = await db.collection('flow').where({
    		   "mainBody.id":mainBody.id
    		}).getTemp()
    		const n = await db.collection(r, 'flowNode').get()
    		if (n.data.length > 0) {
    			return {
    				code: true,
    				data: n.data
    			}
    
    		} else {
    			return {
    				code: false,
    				errMsg: "查无数据"
    			}
    
    		}
    
    	} catch (e) {
    		return {
    			code: false,
    			errMsg: e
    		}
    
    	}
    },
	async addFlow(data){
		try{
			const r=await db.collection('flow').add(data)
			if(r.id){
				return {
					code:true,
					data:r.id
				}
			}
		}catch(e){
			return{
				code:false,
				errMsg:'流程添加失败'
			}
		}
	
	
	}
	
    
}
